The companion oops branch now captures the posterior stddev before the
in-place ana_pert mutation but prints it in its original position, so
the variance-before-mean testref updates are no longer needed. The PR
now touches no testrefs (per-member output is byte-identical to the
legacy path).

Correctness:
- async gather/scatter: give each in-flight MPI_Igatherv/Iscatterv its own
  rc/disp column (the shared rc(:)/disp(:) were recomputed each loop
  iteration while a prior nonblocking collective was still using them)
- writer async gather: allocate a 1-element dummy recvbuf on non-root PEs
  instead of passing an unallocated actual argument to MPI_Igatherv

Cleanup:
- strip profiling instrumentation (OOPS_PERF prints, system_clock blocks,
  measurement-only mpp_sync barriers between phases) from the bulk
  read/write orchestrators
- remove dead code: 3 unused public getters, the unused pelist out-arg of
  the comm helper (now current_mpi_comm), unreachable root_pe/reader_pe
  sentinel loops
- assert all writers/readers in a batch share one FMS domain
- correct the stale 'follow-up' doc comment on State::readEnsemble

- factor the per-domain atlas->compute-domain copy + writer enqueue out of
  soca_fields_write_rst and soca_fields_write_ensemble into a shared
  soca_fields_enqueue_domain helper, so the single-state and bulk paths no
  longer carry two copies of the mask/fillvalue and enqueue logic
- replace the four separate MPI_Allgather calls of the static compute-domain
  bounds (copy-pasted across the three bulk I/O routines) with one packed
  Allgather in a gather_compute_domains helper: 12 collectives per call drop
  to 3, with the rank-ordered layout the Igatherv/Iscatterv paths rely on
  preserved exactly

geometry.io.'ensemble batch size' caps how many members are built,
committed, and freed per bulk read/write pass. Default 0 keeps the
single-batch behavior (all members at once, maximum overlap) and is
byte-identical to the prior path; a positive N processes the ensemble
in waves of at most N members so peak memory is bounded by one wave's
writers/readers plus scratch rather than the whole ensemble. The
writer/reader root PE is rotated by position within the batch so each
wave still spreads its members one-per-PE across the comm.

Validated on the 1deg 7-member LETKF: batch 1/2/none give bit-identical
analysis (nccmp -d); batch 1 cuts total memory ~27% (21.4 -> 15.6 GB)
at the cost of wall time, matching the serial memory floor.

Both async paths posted every (member, var) collective up front, then did
one MPI_Waitall, unpacked all, and freed all buffers at the end. That held
every request's transient buffer live simultaneously: on the write side the
per-root recv buffers (each a full global field), on the read side the
per-root send buffers (full global, packed from gbuf). With the whole
ensemble in one batch that doubled the global-field memory at peak.

Replace the Waitall + unpack-all + free-all with an MPI_Waitany loop: as
each gather/scatter completes, free its send buffer, unpack (on the target
root) into the gbuf / caller slice, and free its recv buffer immediately.
All requests are still posted up front, so the runtime overlap is unchanged;
only the transient high-water drops from all requests to the in-flight set.

1deg 7-member LETKF, single batch: total memory 21.38 -> 19.08 GB (-10.8%),
max RSS -10.7%, wall unchanged, analysis bit-identical (nccmp -d) and ctests
green.

The ensemble write path carried two ways to serialize: the 'ensemble write:
sequential' knob (commit each writer fully, one at a time) and, since the
batch-size knob landed, batch 1 (commit one member's writers per pass through
the orchestrator). They serve the same purpose -- bound peak memory by not
holding the whole ensemble's buffers at once -- and batch 1 already matches a
serial write's memory profile, so the separate sequential path was redundant
A/B scaffolding.

Remove ensemble_write_parallel_, its 'ensemble write' YAML key, the public
getter, and the fallback branch; soca_fields_write_ensemble now always commits
through the orchestrator and relies on 'ensemble batch size' for serialization.
The single-writer commit() method stays (still used by the single-state write,
geometry, and balance paths). Also drop two dead nx_g/ny_g locals in the write
gather. ctests green.